from datetime import datetime

from flask import request

from flask_jwt_extended import jwt_required
from flask_restx import Namespace, Resource, fields
from app1 import db

from app1.models import Zbfwbuserrole, Zbfwbrole, Zbfwbuser

# 创建 Flask-RESTx 命名空间
ns_user_role = Namespace('ns_user_role', description='User Role operations')

# 使用 Flask-RESTx 定义用户数据模型
user_role_model = ns_user_role.model('Zbfwbuserrole', {
    'id': fields.Integer(readOnly=True, description='The user role unique identifier'),
    'uid': fields.String(required=True, description='uid'),
    'rid': fields.String(required=True, description='rid'),
    'desc': fields.String(required=True, description='desc'),
    'create_time': fields.DateTime(description='User Role creation time'),
    'update_time': fields.DateTime(description='User Role update time')
})

# 定义外层的响应模型
response_user_role_model = ns_user_role.model('Response_User_Role', {
    'message': fields.Nested(ns_user_role.model('Message_User_Role', {
        "result": fields.Integer(description='查询结果返回值'),
        "result_text": fields.String(description='查询结果信息'),
        'count': fields.Integer(description='查询结果返回数据条数'),
        'data': fields.List(fields.Nested(user_role_model))
    }))
})

# 使用 Flask-RESTx 定义用户数据模型
user_role_query_model = ns_user_role.model('Zbfwbuserrole', {
    'id': fields.Integer(required=True, description='The user role unique identifier'),
    'uid': fields.Integer(required=True, description='The user  unique identifier'),
    'rid': fields.Integer(required=True, description='The role unique identifier'),
    'desc': fields.String(required=True, description='desc', default=""),
})

# 使用 Flask-RESTx 定义用户数据模型
user_role_add_model = ns_user_role.model('Zbfwbuserroleadd', {
    'uid': fields.Integer(required=True, description='The user  unique identifier'),
    'rid': fields.Integer(required=True, description='The role unique identifier'),
    'desc': fields.String(required=True, description='desc', default=""),
})

# 使用 Flask-RESTx 定义用户数据模型
user_role_delete_model = ns_user_role.model('Zbfwbuserroledelete', {
    'id': fields.Integer(required=True, description='The user role unique identifier'),
})

# 使用 Flask-RESTx 定义用户数据模型
user_role_upd_model = ns_user_role.model('Zbfwbuserroleupd', {
    'id': fields.Integer(required=True, description='The user role unique identifier'),
    'uid': fields.Integer(required=True, description='The user  unique identifier'),
    'rid': fields.Integer(required=True, description='The role unique identifier'),
    'desc': fields.String(required=True, description='desc', default=""),
})


# 查询
@ns_user_role.route('/User_role_list')
class RoleResource(Resource):
    # @jwt_required()
    @ns_user_role.expect(user_role_query_model)
    @ns_user_role.marshal_with(response_user_role_model)
    def post(self):
        """根据输入的id 或者 name 或者 title 匹配查询，如果输入值为空，则指匹配全部"""
        data = request.get_json()

        # 构建查询条件
        query = Zbfwbuserrole.query
        if 'id' in data and data['id']:
            query = query.filter_by(id=data['id'])
        if 'uid' in data and data['uid']:
            query = query.filter_by(uid=data['uid'])
        if 'rid' in data and data['rid']:
            query = query.filter_by(rid=data['rid'])
        if 'desc' in data and data['desc']:
            query = query.filter(Zbfwbuserrole.desc.like(f"%{data['desc']}%"))

        user_roles = query.all()

        return {
            'message': {
                'result': 0,
                'result_text': '查询成功',
                'count': len(user_roles),
                'data': [user_role.to_dict() for user_role in user_roles]
            }
        }


# 新增
@ns_user_role.route('/User_role_create')
class RoleAddResource(Resource):
    # @jwt_required()
    @ns_user_role.expect(user_role_add_model)
    @ns_user_role.marshal_with(response_user_role_model)
    def post(self):
        """ id 为当前总记录加1，name 和 title 需要输入"""
        data = request.get_json()

        # 类型检查
        try:
            uid = int(data['uid'])
            rid = int(data['rid'])
        except (ValueError, TypeError):
            return {
                'message': {
                    'result': 1,
                    'result_text': '用户ID和角色ID必须是整数',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查用户是否存在
        user = Zbfwbuser.query.filter_by(t_zbfwb_user_id=uid).first()
        if not user:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'用户ID {uid} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查角色是否存在
        role = Zbfwbrole.query.filter_by(zbfwb_role_id=rid).first()
        if not role:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'角色ID {rid} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查关系是否已存在
        existing = Zbfwbuserrole.query.filter_by(
            uid=data['uid'],
            rid=data['rid']
        ).first()

        if existing:
            return {
                'message': {
                    'result': 1,
                    'result_text': '该用户角色关系已存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        try:
            # 创建新关系
            new_user_role = Zbfwbuserrole(
                uid=data['uid'],
                rid=data['rid'],
                desc=data.get('desc')
            )

            db.session.add(new_user_role)
            db.session.commit()

            # 重新查询以获取关联的用户和角色信息
            created_user_role = Zbfwbuserrole.query.get(new_user_role.id)

            return {
                'message': {
                    'result': 0,
                    'result_text': '用户角色关系创建成功',
                    'count': 1,
                    'data': [created_user_role.to_dict()]
                }
            }, 201
        except Exception as e:
            db.session.rollback()
            return {
                'message': {
                    'result': 1,
                    'result_text': f'创建用户角色关系失败: {str(e)}',
                    'count': 0,
                    'data': []
                }
            }, 500


# 删除
@ns_user_role.route('/User_role_delete')
class RoleDeleteResource(Resource):
    # @jwt_required()
    @ns_user_role.expect(user_role_delete_model)
    @ns_user_role.marshal_with(response_user_role_model)
    def post(self):
        """Delete a User role"""
        data = request.get_json()

        if not data.get('id'):
            return {
                'message': {
                    'result': 1,
                    'result_text': 'ID不能为空',
                    'count': 0,
                    'data': []
                }
            }, 400

        try:
            # 先获取完整数据用于返回
            user_role = Zbfwbuserrole.query.get(data['id'])
            if not user_role:
                return {
                    'message': {
                        'result': 1,
                        'result_text': '用户角色关系不存在',
                        'count': 0,
                        'data': []
                    }
                }, 404

            # 在删除前先获取需要返回的数据
            response_data = user_role.to_dict()

            # 执行删除操作
            db.session.delete(user_role)
            db.session.commit()

            return {
                'message': {
                    'result': 0,
                    'result_text': '用户角色关系删除成功',
                    'count': 1,
                    'data': [response_data]
                }
            }
        except Exception as e:
            db.session.rollback()
            return {
                'message': {
                    'result': 1,
                    'result_text': f'删除用户角色关系失败: {str(e)}',
                    'count': 0,
                    'data': []
                }
            }, 500


# 修改
@ns_user_role.route('/User_role_updt')
class RoleUpdateResource(Resource):
    # @jwt_required()
    @ns_user_role.expect(user_role_upd_model)
    @ns_user_role.marshal_with(response_user_role_model)
    def post(self):
        """Update a role"""
        data = request.get_json()

        # 检查必填字段
        if not data.get('id') or not data.get('uid') or not data.get('rid'):
            return {
                'message': {
                    'result': 1,
                    'result_text': 'ID、用户ID和角色ID不能为空',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 类型检查
        try:
            uid = int(data['uid'])
            rid = int(data['rid'])
        except (ValueError, TypeError):
            return {
                'message': {
                    'result': 1,
                    'result_text': '用户ID和角色ID必须是整数',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查用户是否存在
        user = Zbfwbuser.query.filter_by(t_zbfwb_user_id=uid).first()
        if not user:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'用户ID {uid} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查角色是否存在
        role = Zbfwbrole.query.filter_by(zbfwb_role_id=rid).first()
        if not role:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'角色ID {rid} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 查找要更新的关系
        user_role = Zbfwbuserrole.query.get(data['id'])
        if not user_role:
            return {
                'message': {
                    'result': 1,
                    'result_text': '用户角色关系不存在',
                    'count': 0,
                    'data': []
                }
            }, 404

        # 检查是否与其他记录冲突
        existing = Zbfwbuserrole.query.filter(
            Zbfwbuserrole.uid == uid,
            Zbfwbuserrole.rid == rid,
            Zbfwbuserrole.id != data['id']
        ).first()

        if existing:
            return {
                'message': {
                    'result': 1,
                    'result_text': '该用户角色关系已存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        try:
            # 更新关系
            user_role.uid = uid
            user_role.rid = rid
            user_role.desc = data.get('desc', user_role.desc)
            user_role.update_time = datetime.utcnow()

            db.session.commit()

            # 重新查询以获取关联的用户和角色信息
            updated_user_role = Zbfwbuserrole.query.get(data['id'])

            return {
                'message': {
                    'result': 0,
                    'result_text': '用户角色关系更新成功',
                    'count': 1,
                    'data': [updated_user_role.to_dict()]
                }
            }
        except Exception as e:
            db.session.rollback()
            return {
                'message': {
                    'result': 1,
                    'result_text': f'更新用户角色关系失败: {str(e)}',
                    'count': 0,
                    'data': []
                }
            }, 500
